
let arr = [8, 2, 5, 1];
// 常用方法 map  filter  reduce  forEach  find  findIndex  every  some

// map  映射，(对数组中每个元素独立执行一下函数)  将数组中的每个元素映射成一个新的元素
let arr2 = arr.map((item, index) => {
    return item * 2;
});
console.log(arr2);
// filter  过滤，(对数组中每个元素独立执行一下函数)  将数组中满足条件的元素过滤出来
let arr3 = arr.filter((item, index) => {
    return item > 3;
});
console.log(arr3);
// reduce  累加，(参数，累计器(上一个函数的处理结果)、当前元素，当前下标  将数组中的元素累加起来
let arr4 = arr.reduce((prev, item, index) => {
    return prev + item;
})
console.log(arr4);

// reduce  累加，(参数，累计器(上一个函数的处理结果)、当前元素，当前下标  将数组中的元素累加起来
let arr4_1 = arr.reduce((prev, item, index) => {
    console.log(prev, item, index);
    return item;
})
console.log(arr4_1);
// forEach  遍历，(参数，当前元素，当前下标)  将数组中的每个元素遍历一遍
arr.forEach((item, index) => {
    console.log(item, index);
})

// find  查找，(参数，当前元素，当前下标)  查找数组中第一个满足条件的元素
let arr5 = arr.find((item, index) => {
    return item > 3;
})
console.log(arr5);

// findIndex  查找，(参数，当前元素，当前下标)  查找数组中第一个满足条件的元素的下标
let arr6 = arr.findIndex((item, index) => {
    return item > 5;
})
console.log(arr6);

// every  检查  检查数组中每个元素是否都满足条件
let arr7 = arr.every((item, index) => {
    return item > 3;
})
console.log(arr7);

// some  检查  检查数组中是否有满足条件的元素
let arr8 = arr.some((item, index) => {
    return item > 3;
})
console.log(arr8);

// includes  检查  检查数组中是否有满足条件的元素
let arr8_1 = arr.includes(3);
console.log("arr8_1-------->", arr8_1, arr);

// sort  排序  将数组中的元素按照某种规则排序
let arr9 = arr.sort((a, b) => {
    // return a - b; // sort默认按照字符串排序，所以需要传入一个函数，按照数字排序。负数表示a在前，正数表示b在前（升序），0表示相等
    return b - a; // sort默认按照字符串排序，所以需要传入一个函数，按照数字排序。负数表示减数在前，正数表示被减数在前（升序），0表示相等
})
console.log("arr9", arr9, arr);
console.log("arr9", arr9, arr.sort()); // arr9sort()会改变原数组，所以需要将原数组赋值给一个新变量
console.log("arr9", arr9, arr);

// reverse  反转  将数组中的元素反转
let arr10 = arr.reverse();
console.log("arr10", arr10, arr);

// splice  删除，(参数，删除的起始下标，删除的个数)  删除数组中的元素
let arr11 = arr.splice(1, 1); // 返回数组，元素是删除的元素
console.log("arr11", arr11, arr);
// splice  添加，(参数，删除的起始下标，删除的个数，添加的元素)  添加数组中的元素
let arr12 = arr.splice(1, 0, 3, 4, 5); // 返回数组，元素是删除的元素
console.log("arr12", arr12, arr);
// splice  替换，(参数，删除的起始下标，删除的个数，添加的元素)  替换数组中的元素【总的来说就是先按下标与数量删除，在按下标插入后面的参数(元素)】
let arr13 = arr.splice(1, 2, 3, 4, 5); // 返回数组，元素是删除的元素
console.log("arr13", arr13, arr);
// slice  截取，(参数，起始下标，结束下标)  截取数组中的元素
let arr14 = arr.slice(1, 3); // 返回数组，元素是截取的元素
console.log("arr14", arr14, arr);
// join  连接，(参数，连接符)  将数组中的元素连接成一个字符串
let arr15 = arr.join("-"); // 返回字符串，元素是连接的字符串
console.log("arr15", arr15, arr);
// concat  连接，(参数，连接的数组)  将数组中的元素连接成一个数组
let arr16 = arr.concat([1, 2, 3]); // 返回数组，元素是连接的数组
console.log("arr16", arr16, arr);
// flat  扁平化，(参数，扁平化的层数（削减的层次）)  将数组中的元素扁平化【将嵌套数组的数组转成一维数组(多维->一维)】
// let dwArr = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
let dwArr = [[1, 2], [3, 4, [5, 6, [7, 8, [9, 10]]]]];
// Infinity 正无穷
let arr17 = dwArr.flat(Infinity); // 返回数组，元素是扁平化的数组
console.log("arr17", arr17, '---', dwArr);
// flatMap  扁平化，(参数，回调函数)  将数组中的元素扁平化【将嵌套数组的元素按函数变化消减一层纬度】
// let arr18 = dwArr.flatMap((item, index) => {
//     console.log("item", item, index);
//     return item.flat(1);
// })
// 等同于 map+flat 的组合
// let arr18 = dwArr.map((item, index) => {
//     console.log("item", item, index);
//     return item.flat
// })
// 简写
let arr18 = dwArr.map((item, index) => item).flat(1);
console.log("arr18", arr18, '---', dwArr);

// reduce  汇总，(参数，初始值)  将数组中的元素汇总
// 格式 arr.reduce((累计器, 当前元素, 当前下标) => { return 累计器 + 当前元素 }, 初始值)

// reduce 示例1, 求和 【将数组中的元素累加起来】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, 0：reduce累计的初始值
let arr19 = arr.reduce((prev, item) => prev + item, 0);
console.log("arr19", arr19, '---', arr);
// reduce 示例2, 求最大值 【将数组中的元素比较，找出最大值】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, 0：reduce累计的初始值
let arr20 = arr.reduce((prev, item) => prev > item ? prev : item, 0);
console.log("arr20", arr20, '---', arr);
// reduce 示例3, 求最小值 【将数组中的元素比较，找出最小值】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, 0：reduce累计的初始值
let arr21 = arr.reduce((prev, item) => prev < item ? prev : item, 0);
console.log("arr21", arr21, '---', arr);
// reduce 示例4, 求平均值 【将数组中的元素累加起来，然后除以数组长度】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, 0：reduce累计的初始值
let arr22 = arr.reduce((prev, item) => prev + item, 0) / arr.length;
console.log("arr22", arr22, '---', arr);
// reduce 示例5, 数组扁平化 【将嵌套数组的数组转成一维数组(多维->一维)】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, []：reduce累计的初始值
let arr23 = dwArr.reduce((prev, item) => prev.concat(item), []);
console.log("arr23", arr23, '---', dwArr);
// reduce 示例6, 数组去重 【将数组中的元素去重】 累计器(函数)上一个函数的返回值，item(函数)当前元素，index(函数)当前下标, []：reduce累计的初始值
let arr24 = arr.reduce((prev, item) => prev.includes(item) ? prev : prev.concat(item), []);
console.log("arr24", arr24, '---', arr);


